home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / gas_251.zip / bin_251 / opcodes / i960-dis.c < prev    next >
C/C++ Source or Header  |  1994-10-13  |  20KB  |  862 lines
  1. /* Disassemble i80960 instructions.
  2.    Copyright (C) 1990, 1991 Free Software Foundation, Inc.
  3.  
  4. This program is free software; you can redistribute it and/or modify
  5. it under the terms of the GNU General Public License as published by
  6. the Free Software Foundation; either version 2, or (at your option)
  7. any later version.
  8.  
  9. This program is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12. GNU General Public License for more details.
  13.  
  14. You should have received a copy of the GNU General Public License
  15. along with this program; see the file COPYING.  If not, write to
  16. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17.  
  18. #include "dis-asm.h"
  19.  
  20. static const char *const reg_names[] = {
  21. /*  0 */    "pfp", "sp",  "rip", "r3",  "r4",  "r5",  "r6",  "r7", 
  22. /*  8 */    "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
  23. /* 16 */    "g0",  "g1",  "g2",  "g3",  "g4",  "g5",  "g6",  "g7", 
  24. /* 24 */    "g8",  "g9",  "g10", "g11", "g12", "g13", "g14", "fp", 
  25. /* 32 */    "pc",  "ac",  "ip",  "tc",  "fp0", "fp1", "fp2", "fp3" 
  26. };
  27.  
  28.  
  29. static FILE *stream;        /* Output goes here */
  30. static struct disassemble_info *info;
  31. static void print_addr();
  32. static void ctrl();
  33. static void cobr();
  34. static void reg();
  35. static int mem();
  36. static void ea();
  37. static void dstop();
  38. static void regop();
  39. static void invalid();
  40. static int pinsn();
  41. static void put_abs();
  42.  
  43.  
  44. /* Print the i960 instruction at address 'memaddr' in debugged memory,
  45.    on INFO->STREAM.  Returns length of the instruction, in bytes.  */
  46.  
  47. int
  48. print_insn_i960 (memaddr, info_arg)
  49.     bfd_vma memaddr;
  50.     struct disassemble_info *info_arg;
  51. {
  52.   unsigned int word1, word2 = 0xdeadbeef;
  53.   bfd_byte buffer[8];
  54.   int status;
  55.  
  56.   info = info_arg;
  57.   stream = info->stream;
  58.  
  59.   /* Read word1.  Only read word2 if the instruction
  60.      needs it, to prevent reading past the end of a section.  */
  61.  
  62.   status = (*info->read_memory_func) (memaddr, (bfd_byte *) buffer, 4, info);
  63.   if (status != 0)
  64.     {
  65.       (*info->memory_error_func) (status, memaddr, info);
  66.       return -1;
  67.     }
  68.  
  69.   word1 = bfd_getl32 (buffer);
  70.  
  71.   /* Divide instruction set into classes based on high 4 bits of opcode.  */
  72.   switch ( (word1 >> 28) & 0xf )
  73.     {
  74.     default:
  75.       break;
  76.     case 0x8:
  77.     case 0x9:
  78.     case 0xa:
  79.     case 0xb:
  80.     case 0xc:
  81.       /* Read word2.  */
  82.       status = (*info->read_memory_func)
  83.     (memaddr + 4, (bfd_byte *) (buffer + 4), 4, info);
  84.       if (status != 0)
  85.     {
  86.       (*info->memory_error_func) (status, memaddr, info);
  87.       return -1;
  88.     }
  89.       word2 = bfd_getl32 (buffer + 4);
  90.       break;
  91.     }
  92.  
  93.   return pinsn( memaddr, word1, word2 );
  94. }
  95.  
  96. #define IN_GDB
  97.  
  98. /*****************************************************************************
  99.  *    All code below this point should be identical with that of
  100.  *    the disassembler in gdmp960.
  101.  
  102.  A noble sentiment, but at least in cosmetic ways (info->fprintf_func), it
  103.  just ain't so. -kingdon, 31 Mar 93
  104.  *****************************************************************************/
  105.  
  106. struct tabent {
  107.     char    *name;
  108.     char    numops;
  109. };
  110.  
  111. struct sparse_tabent {
  112.   int opcode;
  113.   char *name;
  114.   char numops;
  115. };
  116.  
  117. static int
  118. pinsn( memaddr, word1, word2 )
  119.     unsigned long memaddr;
  120.     unsigned long word1, word2;
  121. {
  122.     int instr_len;
  123.  
  124.     instr_len = 4;
  125.     put_abs( word1, word2 );
  126.  
  127.     /* Divide instruction set into classes based on high 4 bits of opcode*/
  128.     switch ( (word1 >> 28) & 0xf ){
  129.     case 0x0:
  130.     case 0x1:
  131.         ctrl( memaddr, word1, word2 );
  132.         break;
  133.     case 0x2:
  134.     case 0x3:
  135.         cobr( memaddr, word1, word2 );
  136.         break;
  137.     case 0x5:
  138.     case 0x6:
  139.     case 0x7:
  140.         reg( word1 );
  141.         break;
  142.     case 0x8:
  143.     case 0x9:
  144.     case 0xa:
  145.     case 0xb:
  146.     case 0xc:
  147.         instr_len = mem( memaddr, word1, word2, 0 );
  148.         break;
  149.     default:
  150.         /* invalid instruction, print as data word */ 
  151.         invalid( word1 );
  152.         break;
  153.     }
  154.     return instr_len;
  155. }
  156.  
  157. /****************************************/
  158. /* CTRL format                */
  159. /****************************************/
  160. static void
  161. ctrl( memaddr, word1, word2 )
  162.     unsigned long memaddr;
  163.     unsigned long word1, word2;
  164. {
  165.     int i;
  166.     static const struct tabent ctrl_tab[] = {
  167.         NULL,        0,    /* 0x00 */
  168.         NULL,        0,    /* 0x01 */
  169.         NULL,        0,    /* 0x02 */
  170.         NULL,        0,    /* 0x03 */
  171.         NULL,        0,    /* 0x04 */
  172.         NULL,        0,    /* 0x05 */
  173.         NULL,        0,    /* 0x06 */
  174.         NULL,        0,    /* 0x07 */
  175.         "b",        1,    /* 0x08 */
  176.         "call",        1,    /* 0x09 */
  177.         "ret",        0,    /* 0x0a */
  178.         "bal",        1,    /* 0x0b */
  179.         NULL,        0,    /* 0x0c */
  180.         NULL,        0,    /* 0x0d */
  181.         NULL,        0,    /* 0x0e */
  182.         NULL,        0,    /* 0x0f */
  183.         "bno",        1,    /* 0x10 */
  184.         "bg",        1,    /* 0x11 */
  185.         "be",        1,    /* 0x12 */
  186.         "bge",        1,    /* 0x13 */
  187.         "bl",        1,    /* 0x14 */
  188.         "bne",        1,    /* 0x15 */
  189.         "ble",        1,    /* 0x16 */
  190.         "bo",        1,    /* 0x17 */
  191.         "faultno",    0,    /* 0x18 */
  192.         "faultg",    0,    /* 0x19 */
  193.         "faulte",    0,    /* 0x1a */
  194.         "faultge",    0,    /* 0x1b */
  195.         "faultl",    0,    /* 0x1c */
  196.         "faultne",    0,    /* 0x1d */
  197.         "faultle",    0,    /* 0x1e */
  198.         "faulto",    0,    /* 0x1f */
  199.     };
  200.  
  201.     i = (word1 >> 24) & 0xff;
  202.     if ( (ctrl_tab[i].name == NULL) || ((word1 & 1) != 0) ){
  203.         invalid( word1 );
  204.         return;
  205.     }
  206.  
  207.     (*info->fprintf_func) ( stream, ctrl_tab[i].name );
  208.     if ( word1 & 2 ){        /* Predicts branch not taken */
  209.         (*info->fprintf_func) ( stream, ".f" );
  210.     }
  211.  
  212.     if ( ctrl_tab[i].numops == 1 ){
  213.         /* EXTRACT DISPLACEMENT AND CONVERT TO ADDRESS */
  214.         word1 &= 0x00ffffff;
  215.         if ( word1 & 0x00800000 ){        /* Sign bit is set */
  216.             word1 |= (-1 & ~0xffffff);    /* Sign extend */
  217.         }
  218.         (*info->fprintf_func)( stream, "\t" );
  219.         print_addr( word1 + memaddr );
  220.     }
  221. }
  222.  
  223. /****************************************/
  224. /* COBR format                */
  225. /****************************************/
  226. static void
  227. cobr( memaddr, word1, word2 )
  228.     unsigned long memaddr;
  229.     unsigned long word1, word2;
  230. {
  231.     int src1;
  232.     int src2;
  233.     int i;
  234.  
  235.     static const struct tabent cobr_tab[] = {
  236.         "testno",    1,    /* 0x20 */
  237.         "testg",    1,    /* 0x21 */
  238.         "teste",    1,    /* 0x22 */
  239.         "testge",    1,    /* 0x23 */
  240.         "testl",    1,    /* 0x24 */
  241.         "testne",    1,    /* 0x25 */
  242.         "testle",    1,    /* 0x26 */
  243.         "testo",    1,    /* 0x27 */
  244.         NULL,        0,    /* 0x28 */
  245.         NULL,        0,    /* 0x29 */
  246.         NULL,        0,    /* 0x2a */
  247.         NULL,        0,    /* 0x2b */
  248.         NULL,        0,    /* 0x2c */
  249.         NULL,        0,    /* 0x2d */
  250.         NULL,        0,    /* 0x2e */
  251.         NULL,        0,    /* 0x2f */
  252.         "bbc",        3,    /* 0x30 */
  253.         "cmpobg",    3,    /* 0x31 */
  254.         "cmpobe",    3,    /* 0x32 */
  255.         "cmpobge",    3,    /* 0x33 */
  256.         "cmpobl",    3,    /* 0x34 */
  257.         "cmpobne",    3,    /* 0x35 */
  258.         "cmpoble",    3,    /* 0x36 */
  259.         "bbs",        3,    /* 0x37 */
  260.         "cmpibno",    3,    /* 0x38 */
  261.         "cmpibg",    3,    /* 0x39 */
  262.         "cmpibe",    3,    /* 0x3a */
  263.         "cmpibge",    3,    /* 0x3b */
  264.         "cmpibl",    3,    /* 0x3c */
  265.         "cmpibne",    3,    /* 0x3d */
  266.         "cmpible",    3,    /* 0x3e */
  267.         "cmpibo",    3,    /* 0x3f */
  268.     };
  269.  
  270.     i = ((word1 >> 24) & 0xff) - 0x20;
  271.     if ( cobr_tab[i].name == NULL ){
  272.         invalid( word1 );
  273.         return;
  274.     }
  275.  
  276.     (*info->fprintf_func) ( stream, cobr_tab[i].name );
  277.     if ( word1 & 2 ){        /* Predicts branch not taken */
  278.         (*info->fprintf_func) ( stream, ".f" );
  279.     }
  280.     (*info->fprintf_func)( stream, "\t" );
  281.  
  282.     src1 = (word1 >> 19) & 0x1f;
  283.     src2 = (word1 >> 14) & 0x1f;
  284.  
  285.     if ( word1 & 0x02000 ){        /* M1 is 1 */
  286.         (*info->fprintf_func)( stream, "%d", src1 );
  287.     } else {            /* M1 is 0 */
  288.         (*info->fprintf_func)( stream, reg_names[src1] );
  289.     }
  290.  
  291.     if ( cobr_tab[i].numops > 1 ){
  292.         if ( word1 & 1 ){        /* S2 is 1 */
  293.             (*info->fprintf_func)( stream, ",sf%d,", src2 );
  294.         } else {            /* S1 is 0 */
  295.             (*info->fprintf_func)( stream, ",%s,", reg_names[src2] );
  296.         }
  297.  
  298.         /* Extract displacement and convert to address
  299.          */
  300.         word1 &= 0x00001ffc;
  301.         if ( word1 & 0x00001000 ){    /* Negative displacement */
  302.             word1 |= (-1 & ~0x1fff);    /* Sign extend */
  303.         }
  304.         print_addr( memaddr + word1 );
  305.     }
  306. }
  307.  
  308. /****************************************/
  309. /* MEM format                */
  310. /****************************************/
  311. static int                /* returns instruction length: 4 or 8 */
  312. mem( memaddr, word1, word2, noprint )
  313.     unsigned long memaddr;
  314.     unsigned long word1, word2;
  315.     int noprint;        /* If TRUE, return instruction length, but
  316.                  * don't output any text.
  317.                  */
  318. {
  319.     int i, j;
  320.     int len;
  321.     int mode;
  322.     int offset;
  323.     const char *reg1, *reg2, *reg3;
  324.  
  325.     /* This lookup table is too sparse to make it worth typing in, but not
  326.        so large as to make a sparse array necessary.  We create the table
  327.        at runtime.  */
  328.  
  329.     /*
  330.      * NOTE: In this table, the meaning of 'numops' is:
  331.      *     1: single operand
  332.      *     2: 2 operands, load instruction
  333.      *    -2: 2 operands, store instruction
  334.      */
  335.     static struct tabent *mem_tab;
  336. /* Opcodes of 0x8X, 9X, aX, bX, and cX must be in the table.  */
  337. #define MEM_MIN    0x80
  338. #define MEM_MAX    0xcf
  339. #define MEM_SIZ    ( * sizeof(struct tabent))
  340.  
  341.     static const struct sparse_tabent mem_init[] = {
  342.         0x80,    "ldob",     2,
  343.         0x82,    "stob",    -2,
  344.         0x84,    "bx",     1,
  345.         0x85,    "balx",     2,
  346.         0x86,    "callx", 1,
  347.         0x88,    "ldos",     2,
  348.         0x8a,    "stos",    -2,
  349.         0x8c,    "lda",     2,
  350.         0x90,    "ld",     2,
  351.         0x92,    "st",    -2,
  352.         0x98,    "ldl",     2,
  353.         0x9a,    "stl",    -2,
  354.         0xa0,    "ldt",     2,
  355.         0xa2,    "stt",    -2,
  356.         0xb0,    "ldq",     2,
  357.         0xb2,    "stq",    -2,
  358.         0xc0,    "ldib",     2,
  359.         0xc2,    "stib",    -2,
  360.         0xc8,    "ldis",     2,
  361.         0xca,    "stis",    -2,
  362.         0,    NULL,    0
  363.     };
  364.     static struct tabent mem_tab_buf[MEM_MAX - MEM_MIN + 1];
  365.  
  366.     if ( mem_tab == NULL ){
  367.         mem_tab = mem_tab_buf;
  368.         for ( i = 0; mem_init[i].opcode != 0; i++ ){
  369.             j = mem_init[i].opcode - MEM_MIN;
  370.             mem_tab[j].name = mem_init[i].name;
  371.             mem_tab[j].numops = mem_init[i].numops;
  372.         }
  373.     }
  374.  
  375.     i = ((word1 >> 24) & 0xff) - MEM_MIN;
  376.     mode = (word1 >> 10) & 0xf;
  377.  
  378.     if ( (mem_tab[i].name != NULL)        /* Valid instruction */
  379.     &&   ((mode == 5) || (mode >=12)) ){    /* With 32-bit displacement */
  380.         len = 8;
  381.     } else {
  382.         len = 4;
  383.     }
  384.  
  385.     if ( noprint ){
  386.         return len;
  387.     }
  388.  
  389.     if ( (mem_tab[i].name == NULL) || (mode == 6) ){
  390.         invalid( word1 );
  391.         return len;
  392.     }
  393.  
  394.     (*info->fprintf_func)( stream, "%s\t", mem_tab[i].name );
  395.  
  396.     reg1 = reg_names[ (word1 >> 19) & 0x1f ];    /* MEMB only */
  397.     reg2 = reg_names[ (word1 >> 14) & 0x1f ];
  398.     reg3 = reg_names[ word1 & 0x1f ];        /* MEMB only */
  399.     offset = word1 & 0xfff;                /* MEMA only  */
  400.  
  401.     switch ( mem_tab[i].numops ){
  402.  
  403.     case 2: /* LOAD INSTRUCTION */
  404.         if ( mode & 4 ){            /* MEMB FORMAT */
  405.             ea( memaddr, mode, reg2, reg3, word1, word2 );
  406.             (*info->fprintf_func)( stream, ",%s", reg1 );
  407.         } else {                /* MEMA FORMAT */
  408.             (*info->fprintf_func)( stream, "0x%x", (unsigned) offset );
  409.             if (mode & 8) {
  410.                 (*info->fprintf_func)( stream, "(%s)", reg2 );
  411.             }
  412.             (*info->fprintf_func)( stream, ",%s", reg1 );
  413.         }
  414.         break;
  415.  
  416.     case -2: /* STORE INSTRUCTION */
  417.         if ( mode & 4 ){            /* MEMB FORMAT */
  418.             (*info->fprintf_func)( stream, "%s,", reg1 );
  419.             ea( memaddr, mode, reg2, reg3, word1, word2 );
  420.         } else {                /* MEMA FORMAT */
  421.             (*info->fprintf_func)( stream, "%s,0x%x", reg1, (unsigned) offset );
  422.             if (mode & 8) {
  423.                 (*info->fprintf_func)( stream, "(%s)", reg2 );
  424.             }
  425.         }
  426.         break;
  427.  
  428.     case 1: /* BX/CALLX INSTRUCTION */
  429.         if ( mode & 4 ){            /* MEMB FORMAT */
  430.             ea( memaddr, mode, reg2, reg3, word1, word2 );
  431.         } else {                /* MEMA FORMAT */
  432.             (*info->fprintf_func)( stream, "0x%x", (unsigned) offset );
  433.             if (mode & 8) {
  434.                 (*info->fprintf_func)( stream, "(%s)", reg2 );
  435.             }
  436.         }
  437.         break;
  438.     }
  439.  
  440.     return len;
  441. }
  442.  
  443. /****************************************/
  444. /* REG format                */
  445. /****************************************/
  446. static void
  447. reg( word1 )
  448.     unsigned long word1;
  449. {
  450.     int i, j;
  451.     int opcode;
  452.     int fp;
  453.     int m1, m2, m3;
  454.     int s1, s2;
  455.     int src, src2, dst;
  456.     char *mnemp;
  457.  
  458.     /* This lookup table is too sparse to make it worth typing in, but not
  459.        so large as to make a sparse array necessary.  We create the table
  460.        at runtime.  */
  461.  
  462.     /*
  463.      * NOTE: In this table, the meaning of 'numops' is:
  464.      *     1: single operand, which is NOT a destination.
  465.      *    -1: single operand, which IS a destination.
  466.      *     2: 2 operands, the 2nd of which is NOT a destination.
  467.      *    -2: 2 operands, the 2nd of which IS a destination.
  468.      *     3: 3 operands
  469.      *
  470.      *    If an opcode mnemonic begins with "F", it is a floating-point
  471.      *    opcode (the "F" is not printed).
  472.      */
  473.  
  474.     static struct tabent *reg_tab;
  475.     static const struct sparse_tabent reg_init[] = {
  476. #define REG_MIN    0x580
  477.         0x580,    "notbit",    3,
  478.         0x581,    "and",        3,
  479.         0x582,    "andnot",    3,
  480.         0x583,    "setbit",    3,
  481.         0x584,    "notand",    3,
  482.         0x586,    "xor",        3,
  483.         0x587,    "or",        3,
  484.         0x588,    "nor",        3,
  485.         0x589,    "xnor",        3,
  486.         0x58a,    "not",        -2,
  487.         0x58b,    "ornot",    3,
  488.         0x58c,    "clrbit",    3,
  489.         0x58d,    "notor",    3,
  490.         0x58e,    "nand",        3,
  491.         0x58f,    "alterbit",    3,
  492.         0x590,     "addo",        3,
  493.         0x591,     "addi",        3,
  494.         0x592,     "subo",        3,
  495.         0x593,     "subi",        3,
  496.         0x598,     "shro",        3,
  497.         0x59a,     "shrdi",    3,
  498.         0x59b,     "shri",        3,
  499.         0x59c,     "shlo",        3,
  500.         0x59d,     "rotate",    3,
  501.         0x59e,     "shli",        3,
  502.         0x5a0,     "cmpo",        2,
  503.         0x5a1,     "cmpi",        2,
  504.         0x5a2,     "concmpo",    2,
  505.         0x5a3,     "concmpi",    2,
  506.         0x5a4,     "cmpinco",    3,
  507.         0x5a5,     "cmpinci",    3,
  508.         0x5a6,     "cmpdeco",    3,
  509.         0x5a7,     "cmpdeci",    3,
  510.         0x5ac,     "scanbyte",    2,
  511.         0x5ae,     "chkbit",    2,
  512.         0x5b0,     "addc",        3,
  513.         0x5b2,     "subc",        3,
  514.         0x5cc,    "mov",        -2,
  515.         0x5d8,    "eshro",    3,
  516.         0x5dc,    "movl",        -2,
  517.         0x5ec,    "movt",        -2,
  518.         0x5fc,    "movq",        -2,
  519.         0x600,    "synmov",    2,
  520.         0x601,    "synmovl",    2,
  521.         0x602,    "synmovq",    2,
  522.         0x603,    "cmpstr",    3,
  523.         0x604,    "movqstr",    3,
  524.         0x605,    "movstr",    3,
  525.         0x610,    "atmod",    3,
  526.         0x612,    "atadd",    3,
  527.         0x613,    "inspacc",    -2,
  528.         0x614,    "ldphy",    -2,
  529.         0x615,    "synld",    -2,
  530.         0x617,    "fill",        3,
  531.         0x630,    "sdma",        3,
  532.         0x631,    "udma",        0,
  533.         0x640,    "spanbit",    -2,
  534.         0x641,    "scanbit",    -2,
  535.         0x642,    "daddc",    3,
  536.         0x643,    "dsubc",    3,
  537.         0x644,    "dmovt",    -2,
  538.         0x645,    "modac",    3,
  539.         0x646,    "condrec",    -2,
  540.         0x650,    "modify",    3,
  541.         0x651,    "extract",    3,
  542.         0x654,    "modtc",    3,
  543.         0x655,    "modpc",    3,
  544.         0x656,    "receive",    -2,
  545.         0x659,    "sysctl",    3,
  546.         0x660,    "calls",    1,
  547.         0x662,    "send",        3,
  548.         0x663,    "sendserv",    1,
  549.         0x664,    "resumprcs",    1,
  550.         0x665,    "schedprcs",    1,
  551.         0x666,    "saveprcs",    0,
  552.         0x668,    "condwait",    1,
  553.         0x669,    "wait",        1,
  554.         0x66a,    "signal",    1,
  555.         0x66b,    "mark",        0,
  556.         0x66c,    "fmark",    0,
  557.         0x66d,    "flushreg",    0,
  558.         0x66f,    "syncf",    0,
  559.         0x670,    "emul",        3,
  560.         0x671,    "ediv",        3,
  561.         0x673,     "ldtime",    -1,
  562.         0x674,    "Fcvtir",    -2,
  563.         0x675,    "Fcvtilr",    -2,
  564.         0x676,    "Fscalerl",    3,
  565.         0x677,    "Fscaler",    3,
  566.         0x680,    "Fatanr",    3,
  567.         0x681,    "Flogepr",    3,
  568.         0x682,    "Flogr",    3,
  569.         0x683,    "Fremr",    3,
  570.         0x684,    "Fcmpor",    2,
  571.         0x685,    "Fcmpr",    2,
  572.         0x688,    "Fsqrtr",    -2,
  573.         0x689,    "Fexpr",    -2,
  574.         0x68a,    "Flogbnr",    -2,
  575.         0x68b,    "Froundr",    -2,
  576.         0x68c,    "Fsinr",    -2,
  577.         0x68d,    "Fcosr",    -2,
  578.         0x68e,    "Ftanr",    -2,
  579.         0x68f,    "Fclassr",    1,
  580.         0x690,    "Fatanrl",    3,
  581.         0x691,    "Flogeprl",    3,
  582.         0x692,    "Flogrl",    3,
  583.         0x693,    "Fremrl",    3,
  584.         0x694,    "Fcmporl",    2,
  585.         0x695,    "Fcmprl",    2,
  586.         0x698,    "Fsqrtrl",    -2,
  587.         0x699,    "Fexprl",    -2,
  588.         0x69a,    "Flogbnrl",    -2,
  589.         0x69b,    "Froundrl",    -2,
  590.         0x69c,    "Fsinrl",    -2,
  591.         0x69d,    "Fcosrl",    -2,
  592.         0x69e,    "Ftanrl",    -2,
  593.         0x69f,    "Fclassrl",    1,
  594.         0x6c0,    "Fcvtri",    -2,
  595.         0x6c1,    "Fcvtril",    -2,
  596.         0x6c2,    "Fcvtzri",    -2,
  597.         0x6c3,    "Fcvtzril",    -2,
  598.         0x6c9,    "Fmovr",    -2,
  599.         0x6d9,    "Fmovrl",    -2,
  600.         0x6e1,     "Fmovre",    -2,
  601.         0x6e2,     "Fcpysre",    3,
  602.         0x6e3,     "Fcpyrsre",    3,
  603.         0x701,    "mulo",        3,
  604.         0x708,    "remo",        3,
  605.         0x70b,    "divo",        3,
  606.         0x741,    "muli",        3,
  607.         0x748,    "remi",        3,
  608.         0x749,    "modi",        3,
  609.         0x74b,    "divi",        3,
  610.         0x78b,    "Fdivr",    3,
  611.         0x78c,    "Fmulr",    3,
  612.         0x78d,    "Fsubr",    3,
  613.         0x78f,    "Faddr",    3,
  614.         0x79b,    "Fdivrl",    3,
  615.         0x79c,    "Fmulrl",    3,
  616.         0x79d,    "Fsubrl",    3,
  617.         0x79f,    "Faddrl",    3,
  618. #define REG_MAX    0x79f
  619.         0,    NULL,    0
  620.     };
  621.     static struct tabent reg_tab_buf[REG_MAX - REG_MIN + 1];
  622.  
  623.     if ( reg_tab == NULL ){
  624.         reg_tab = reg_tab_buf;
  625.         for ( i = 0; reg_init[i].opcode != 0; i++ ){
  626.             j = reg_init[i].opcode - REG_MIN;
  627.             reg_tab[j].name = reg_init[i].name;
  628.             reg_tab[j].numops = reg_init[i].numops;
  629.         }
  630.     }
  631.  
  632.     opcode = ((word1 >> 20) & 0xff0) | ((word1 >> 7) & 0xf);
  633.     i = opcode - REG_MIN;
  634.  
  635.     if ( (opcode<REG_MIN) || (opcode>REG_MAX) || (reg_tab[i].name==NULL) ){
  636.         invalid( word1 );
  637.         return;
  638.     }
  639.  
  640.     mnemp = reg_tab[i].name;
  641.     if ( *mnemp == 'F' ){
  642.         fp = 1;
  643.         mnemp++;
  644.     } else {
  645.         fp = 0;
  646.     }
  647.  
  648.     (*info->fprintf_func)( stream, mnemp );
  649.  
  650.     s1   = (word1 >> 5)  & 1;
  651.     s2   = (word1 >> 6)  & 1;
  652.     m1   = (word1 >> 11) & 1;
  653.     m2   = (word1 >> 12) & 1;
  654.     m3   = (word1 >> 13) & 1;
  655.     src  =  word1        & 0x1f;
  656.     src2 = (word1 >> 14) & 0x1f;
  657.     dst  = (word1 >> 19) & 0x1f;
  658.  
  659.     if  ( reg_tab[i].numops != 0 ){
  660.         (*info->fprintf_func)( stream, "\t" );
  661.  
  662.         switch ( reg_tab[i].numops ){
  663.         case 1:
  664.             regop( m1, s1, src, fp );
  665.             break;
  666.         case -1:
  667.             dstop( m3, dst, fp );
  668.             break;
  669.         case 2:
  670.             regop( m1, s1, src, fp );
  671.             (*info->fprintf_func)( stream, "," );
  672.             regop( m2, s2, src2, fp );
  673.             break;
  674.         case -2:
  675.             regop( m1, s1, src, fp );
  676.             (*info->fprintf_func)( stream, "," );
  677.             dstop( m3, dst, fp );
  678.             break;
  679.         case 3:
  680.             regop( m1, s1, src, fp );
  681.             (*info->fprintf_func)( stream, "," );
  682.             regop( m2, s2, src2, fp );
  683.             (*info->fprintf_func)( stream, "," );
  684.             dstop( m3, dst, fp );
  685.             break;
  686.         }
  687.     }
  688. }
  689.  
  690.  
  691. /*
  692.  * Print out effective address for memb instructions.
  693.  */
  694. static void
  695. ea( memaddr, mode, reg2, reg3, word1, word2 )
  696.      unsigned long memaddr;
  697.      int mode;
  698.      char *reg2, *reg3;
  699.      int word1;
  700.      unsigned int word2;
  701. {
  702.     int scale;
  703.     static const int scale_tab[] = { 1, 2, 4, 8, 16 };
  704.  
  705.     scale = (word1 >> 7) & 0x07;
  706.     if ( (scale > 4) || ((word1 >> 5) & 0x03 != 0) ){
  707.         invalid( word1 );
  708.         return;
  709.     }
  710.     scale = scale_tab[scale];
  711.  
  712.     switch (mode) {
  713.     case 4:                         /* (reg) */
  714.         (*info->fprintf_func)( stream, "(%s)", reg2 );
  715.         break;
  716.     case 5:                        /* displ+8(ip) */
  717.         print_addr( word2+8+memaddr );
  718.         break;
  719.     case 7:                        /* (reg)[index*scale] */
  720.         if (scale == 1) {
  721.             (*info->fprintf_func)( stream, "(%s)[%s]", reg2, reg3 );
  722.         } else {
  723.             (*info->fprintf_func)( stream, "(%s)[%s*%d]",reg2,reg3,scale);
  724.         }
  725.         break;
  726.     case 12:                    /* displacement */
  727.         print_addr( word2 );
  728.         break;
  729.     case 13:                    /* displ(reg) */
  730.         print_addr( word2 );
  731.         (*info->fprintf_func)( stream, "(%s)", reg2 );
  732.         break;
  733.     case 14:                    /* displ[index*scale] */
  734.         print_addr( word2 );
  735.         if (scale == 1) {
  736.             (*info->fprintf_func)( stream, "[%s]", reg3 );
  737.         } else {
  738.             (*info->fprintf_func)( stream, "[%s*%d]", reg3, scale );
  739.         }
  740.         break;
  741.     case 15:                /* displ(reg)[index*scale] */
  742.         print_addr( word2 );
  743.         if (scale == 1) {
  744.             (*info->fprintf_func)( stream, "(%s)[%s]", reg2, reg3 );
  745.         } else {
  746.             (*info->fprintf_func)( stream, "(%s)[%s*%d]",reg2,reg3,scale );
  747.         }
  748.         break;
  749.     default:
  750.         invalid( word1 );
  751.         return;
  752.     }
  753. }
  754.  
  755.  
  756. /************************************************/
  757. /* Register Instruction Operand          */
  758. /************************************************/
  759. static void
  760. regop( mode, spec, reg, fp )
  761.     int mode, spec, reg, fp;
  762. {
  763.     if ( fp ){                /* FLOATING POINT INSTRUCTION */
  764.         if ( mode == 1 ){            /* FP operand */
  765.             switch ( reg ){
  766.             case 0:  (*info->fprintf_func)( stream, "fp0" );
  767.               break;
  768.             case 1:  (*info->fprintf_func)( stream, "fp1" );
  769.               break;
  770.             case 2:  (*info->fprintf_func)( stream, "fp2" );
  771.               break;
  772.             case 3:  (*info->fprintf_func)( stream, "fp3" );
  773.               break;
  774.             case 16: (*info->fprintf_func)( stream, "0f0.0" );
  775.               break;
  776.             case 22: (*info->fprintf_func)( stream, "0f1.0" );
  777.               break;
  778.             default: (*info->fprintf_func)( stream, "?" );
  779.               break;
  780.             }
  781.         } else {                /* Non-FP register */
  782.             (*info->fprintf_func)( stream, reg_names[reg] );
  783.         }
  784.     } else {                /* NOT FLOATING POINT */
  785.         if ( mode == 1 ){            /* Literal */
  786.             (*info->fprintf_func)( stream, "%d", reg );
  787.         } else {                /* Register */
  788.             if ( spec == 0 ){
  789.                 (*info->fprintf_func)( stream, reg_names[reg] );
  790.             } else {
  791.                 (*info->fprintf_func)( stream, "sf%d", reg );
  792.             }
  793.         }
  794.     }
  795. }
  796.  
  797. /************************************************/
  798. /* Register Instruction Destination Operand    */
  799. /************************************************/
  800. static void
  801. dstop( mode, reg, fp )
  802.     int mode, reg, fp;
  803. {
  804.     /* 'dst' operand can't be a literal. On non-FP instructions,  register
  805.      * mode is assumed and "m3" acts as if were "s3";  on FP-instructions,
  806.      * sf registers are not allowed so m3 acts normally.
  807.      */
  808.      if ( fp ){
  809.         regop( mode, 0, reg, fp );
  810.      } else {
  811.         regop( 0, mode, reg, fp );
  812.      }
  813. }
  814.  
  815.  
  816. static void
  817. invalid( word1 )
  818.     int word1;
  819. {
  820.     (*info->fprintf_func)( stream, ".word\t0x%08x", (unsigned) word1 );
  821. }    
  822.  
  823. static void
  824. print_addr(a)
  825. int a;
  826. {
  827.   (*info->print_address_func) ((bfd_vma) a, info);
  828. }
  829.  
  830. static void
  831. put_abs( word1, word2 )
  832.     unsigned long word1, word2;
  833. {
  834. #ifdef IN_GDB
  835.     return;
  836. #else
  837.     int len;
  838.  
  839.     switch ( (word1 >> 28) & 0xf ){
  840.     case 0x8:
  841.     case 0x9:
  842.     case 0xa:
  843.     case 0xb:
  844.     case 0xc:
  845.         /* MEM format instruction */
  846.         len = mem( 0, word1, word2, 1 );
  847.         break;
  848.     default:
  849.         len = 4;
  850.         break;
  851.     }
  852.  
  853.     if ( len == 8 ){
  854.         (*info->fprintf_func)( stream, "%08x %08x\t", word1, word2 );
  855.     } else {
  856.         (*info->fprintf_func)( stream, "%08x         \t", word1 );
  857.     }
  858. ;
  859.  
  860. #endif
  861. }
  862.